home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / ARGONET / PD / GRAPHICS / IMAGE165.SPK / !Image / Docs / P8 < prev    next >
Text File  |  1994-02-28  |  6KB  |  143 lines
  1.  
  2. Kernel Operations "An Introduction"
  3.  
  4. Kernel operations are operations on an image which work in the
  5. following manner. Each output pixel is created by using not only data
  6. from the corresponding input pixel, but also its neighbouring pixels -
  7. thus allowing such actions as smoothing, sharpening and noise removal
  8. (plus many other operations) to be performed.
  9.  
  10. In Image a kernel size of 9 is used, thus each pixel plus its eight
  11. nearest neighbours are used. The kernel is specified by giving 11
  12. values, one for each of the kernel positions (these nine values are
  13. collectively termed the kernel mask) and also a multiplier and
  14. a divider. The kernel operation works as follows (per output pixel) :
  15.  
  16.   1) For each of the 8 neighbours and the pixel in question, the pixel
  17.      values (red, green and blue components) are multiplied by the
  18.      relevant value for the kernel operation, the results of all these
  19.      multiplications are then added together.
  20.  
  21.   2) The resultant values (red, green and blue) are then further
  22.      multiplied by the 'multiplier' and then divided by the 'divider'
  23.      to produce the result (output) red green and blue values for the
  24.      pixel in question.
  25.  
  26. This may seem a bit complex, but it is fairly simple, and very
  27. powerful. As an example let us consider the case where the kernel is
  28. defined as :
  29.  
  30.  
  31.         1    1    1        multiplier = 1
  32.         1    1    1
  33.         1    1    1        divider = 9
  34.  
  35. In this case the result is that all nine pixels are added together and
  36. the total divided by 9 - thus the result is the average of the 9 input
  37. values. In cases where the result of a kernel operation is an average
  38. of input values, this tends to make the operation a 'Smoothing'
  39. operation (it will tend to blur the picture, removing harsh lines).
  40.  
  41. If you were to replace the central value in the above kernel with,
  42. say, 4 and make the divider 12 then the result would still be a
  43. smoothing operation, but this time there would be a bias towards the
  44. central input pixel - the result of this is that the smoothing will be
  45. less.
  46.  
  47. In smoothing operations is is generally best to make the multiplier 1
  48. and the divider equal the sum of the kernel position values - this
  49. ensures that the overall brightness of the output image will be
  50. (approximately) the same as that of the input image. By increasing the
  51. multiplier, or reducing the divider, the result will be a brighter
  52. output - whilst increasing the divider will produce a darker output.
  53.  
  54. In fact, often Image can calculate the multiplier and divider required
  55. simply by pressing the 'Auto' button. This button takes the values
  56. currently in the 9 kernel positions and calculates values for the
  57. multiplier and divider which will maintain overall brightness in the
  58. image (the multiplier will always be set to 1, in fact in most kernel
  59. operations the multiplier will be 1).
  60.  
  61. The opposite of a smoothing operation is a sharpening operation, and
  62. this too can be performed by the kernel operation. One way to sharpen
  63. an image is to subtract from it a smoothed version (this may sound
  64. odd, but it works). The simplest of these can be created thus :
  65.  
  66.       -1   -1   -1       multiplier = 1
  67.       -1    9   -1
  68.       -1   -1   -1       divider = 1
  69.  
  70. Another standard kernel operation is that of noise removal (removing
  71. random dots from an image). There are several methods of doing this,
  72. indeed the smoothing operation will tend to smooth out noise. But to
  73. remove noise needs a further trick, and Image can perform just such a
  74. trick.
  75.  
  76. By placing a '<' or a '>' in front of the central value in the kernel
  77. mask you alter the way n which the operation will be performed. In
  78. this case the operation is carried out as before, except that the
  79. central pixel is not used in the calculation (ie. only the 8
  80. neighbours are used, the multiplier and divider values need to take
  81. account of this, the 'Auto' option will take account of this
  82. situation).
  83.  
  84. After the result is known, instead of using it as the output directly,
  85. first this value is subtracted from the input pixel value for the
  86. central pixel (ie. the one missed out in the calculation). The result
  87. of this subtraction is then compared with the value in the central
  88. kernel mask position (the value following the '<' or '>') (this value
  89. should be a value from 0 to 255). If the results is less than (in the
  90. case of '<') or greater than (in the case of '>') the value given then
  91. the result gained from the kernel calculation is used as the output,
  92. otherwise the pixel being worked on is passed directly to the output,
  93. unchanged.
  94.  
  95. What we need here is an example :
  96.  
  97.         1    1    1       multiplier = 1
  98.         1   >50   1
  99.         1    1    1       divider = 8
  100.  
  101. Now let us assume the the pixel intensities for the pixels being
  102. investigated are :
  103.  
  104.        15   12   18
  105.         7   88    9
  106.        11   10   12
  107.  
  108. Now the kernel operation is performed thus, first calculate the kernel
  109. value using the 8 neighbours, etc.
  110.  
  111.    V = ( 15*1 + 12*1 + 18*1 + 7*1 + 9*1 + 11*1 + 10*1 + 12*1 ) * 1 / 8
  112.  
  113.      = 11.75
  114.  
  115. Next we subtract that value from the input pixel being considered
  116. (here 88)
  117.  
  118.    D = 88 - 11.75    (note: absolute value is taken)
  119.  
  120.      = 76.25
  121.  
  122. Now we compare this value with the value given in the central kernel
  123. mask position (50) and note that it is greater. Thus (because the
  124. operation is '>') we use the value 'V' as the output (we output 11.75)
  125. as being the result for that pixel.
  126.  
  127. The result of this operation is the removal of the value 88 which is
  128. uncharacteristic of the surrounding area (ie. likely to be noise). By
  129. altering the value following the '>' we alter the amount of noise
  130. removed (the sensitivity), larger values make it less sensitive, small
  131. values make it more sensitive.
  132.  
  133. But what of the '<' operation, this is of no use to noise removal.
  134. Indeed not, but it has a use of its own. With the '<' operation the
  135. tendency will be to average areas of similar intensity, but preserve
  136. areas of great fluctuation in intensity - the result being a smoothing
  137. operation which tends not to blur edges (unlike the standard smoothing
  138. operations).
  139.  
  140. Finally kernel operations can produce some very odd results,
  141. experimentation can lead to some wonderful effects. 
  142.  
  143.